home *** CD-ROM | disk | FTP | other *** search
/ Danny Amor's Online Library / Danny Amor's Online Library - Volume 1.iso / html / faqs / faq / func-lang-faq < prev    next >
Text File  |  1995-07-25  |  38KB  |  981 lines
  1. Subject: comp.lang.functional Frequently Asked Questions (monthly posting)
  2. Newsgroups: comp.lang.functional,comp.answers,news.answers
  3. From: jones-mark@CS.YALE.EDU (Mark P. Jones)
  4. Date: 14 Jul 1994 16:28:52 GMT
  5.  
  6.  
  7. Archive-name: func-lang-faq
  8. Last-modified: July 14, 1994
  9.  
  10. ---------------------------------------------------------------------------
  11.              A Frequently Asked Questions list (FAQ) for
  12.                       comp.lang.functional
  13. ---------------------------------------------------------------------------
  14. A copy of this FAQ is available by anonymous ftp from nebula.cs.yale.edu in
  15. the file pub/comp.lang.functional/FAQ.
  16. ---------------------------------------------------------------------------
  17. New this month:
  18.  - New ftp sites for the OPAL distribution have been added.
  19.  - A reference to technical report about the implementation of
  20.    Gofer has been added.
  21.  
  22. NOTE: I am just about to move and will be away from email and news
  23. for some time.  As a result, the next posting of this FAQ may well
  24. be delayed.  Normal service will resume as soon as possible.  Feel
  25. free to send further updates for the FAQ by mail, but please do not
  26. be concerned if I do not send a prompt reply!
  27.  
  28. ---------------------------------------------------------------------------
  29. TABLE OF CONTENTS:
  30.  
  31. 1) GENERAL QUESTIONS
  32.    1.1) What is a functional language?
  33.    1.2) Where can I find out more about the history and motivation
  34.         for functional programming?
  35.    1.3) Are there any books about functional programming?
  36.    1.4) Where is a good place to look for information about current
  37.         research in functional languages?
  38.    1.5) What other newsgroups might be of interest to readers of
  39.         comp.lang.functional?
  40.    1.6) Is comp.lang.functional archived anywhere?
  41.  
  42. 2) FREQUENT TOPICS OF DISCUSSION:
  43.    2.1) What is a monad?
  44.    2.2) How can I write a parser in a functional language?
  45.    2.3) What does it mean to say that a language is strict/non-strict?
  46.    2.4) What about the performance of functional programs?
  47.    2.5) What is a purely functional language?
  48.    2.6) Other subjects:
  49.  
  50. 3) LANGUAGE IMPLEMENTATIONS:
  51.    ASpecT, Caml Light, Clean, Erlang, FP, Gofer, Haskell, Hope, Id, IFP,
  52.    J, Miranda(TM), ML, NESL, OPAL, Scheme and Sisal.
  53.  
  54. 4) OTHER RESOURCES:
  55.    4.1) Bibliographies:
  56.    4.2) Translators:
  57.    4.3) Online services:
  58.  
  59. 5) CREDITS AND DISCLAIMERS:
  60.  
  61. ---------------------------------------------------------------------------
  62. 1) GENERAL QUESTIONS:
  63.  
  64. Comp.lang.functional is an unmoderated usenet newsgroup for the
  65. discussion of functional programming languages, including their
  66. design, application, theoretical foundation and implementation.
  67.  
  68. ---------
  69. 1.1) What is a functional language?
  70.  
  71. Opinions differ, even within the functional programming community,
  72. on the precise definition of ``functional programming languages''.
  73. Here is a definition that, broadly speaking, represents the kind of
  74. languages that are discussed in this newsgroup:
  75.  
  76.   Functional programming is a style of programming that emphasizes
  77.   the evaluation of expressions, rather than execution of commands.
  78.   The expressions in these language are formed by using functions to
  79.   combine basic values.
  80.  
  81.   A functional language is a language that supports and encourages
  82.   programming in a functional style.
  83.  
  84.   For example, consider the task of calculating the sum of the
  85.   integers from 1 to 10.  In an imperative language, this might be
  86.   expressed using a loop, repeatedly updating the values held in
  87.   counter and accumulator variables:
  88.  
  89.        total = 0;
  90.        for (i=1; i<=10; ++i)
  91.            total += i;
  92.  
  93.   In a functional language, the same program would be expressed
  94.   without any variable updates.  For example, in Haskell or Miranda,
  95.   the required sum can be calculated by evaluating the expression:
  96.  
  97.        sum [1..10].
  98.  
  99.   Here, [1..10] is an expression that represents the list of integers
  100.   from 1 to 10, while sum is a function that can be used to calculate
  101.   the sum of an arbitrary list of values.
  102.  
  103.   The same idea could also be used in strict languages like ML or
  104.   Scheme, but it is more common to find such programs written with
  105.   an explicit loop, often expressed as a form of recursion.
  106.   Nevertheless, there is still no need to update the values of the
  107.   variables involved.
  108.  
  109.   SML:    let fun sum i tot = if i=0 then tot else sum (i-1) (tot+i)
  110.           in sum 10 0
  111.           end
  112.  
  113.   Scheme: (define sum
  114.              (lambda (from total)
  115.                  (if (= 0 from)
  116.                      total
  117.                      (sum (- from 1) (+ total from)))))
  118.           (sum 10 0)
  119.  
  120.   Of course, it is often possible to write programs in an imperative
  121.   language using a functional style, and vice versa.  It is then
  122.   a matter of opinion whether a particular language can be described
  123.   as functional or not.
  124.  
  125.  
  126. ---------
  127. 1.2) Where can I find out more about the history and motivation
  128. for functional programming?
  129.  
  130. Here are a couple of references that should help:
  131.  
  132.   "Conception, Evolution, and Application of Functional Programming
  133.   Languages", Paul Hudak, ACM Computing Surveys, Volume 21, Number 3,
  134.   pp.359--411, 1989.
  135.  
  136.   "Why functional programming matters", John Hughes, The Computer
  137.   Journal, Volume 32, Number 2, April 1989.
  138.  
  139.  
  140. ---------
  141. 1.3) Are there any books about functional programming?
  142.  
  143. Yes, there are quite a few.  For details about programming in a
  144. functional language:
  145.  
  146.   o  "Introduction to functional programming", Richard Bird and
  147.      Philip Wadler, Prentice Hall, 1988.  ISBN 0-13-484189-1.
  148.  
  149.   o  "ML for the working programmer", L.C. Paulson, Cambridge
  150.      University Press, 1991.  ISBN 0-521-39022-2.
  151.  
  152. And for those with an interest in implementation:
  153.  
  154.   o  "The implementation of functional programming languages",
  155.      Simon Peyton Jones, Prentice Hall, 1987.  ISBN 0-13-453333-X.
  156.  
  157.   o  "Compiling with continuations", Andrew Appel, Cambridge
  158.      University Press, 1992.  ISBN 0-521-41695-7.
  159.  
  160. For brevity, I've restricted myself to two books in each of the
  161. above categories, one concerned with non-strict languages, the
  162. other with strict languages.  There are several other good books
  163. in each category.
  164.  
  165. The following article may also be of interest to those looking for
  166. books about functional programming:
  167.  
  168.   o  Simon Thompson, Comparative review of functional programming
  169.      textbooks (Bailey, Bird and Wadler, Holyer, Paulson, Reade,
  170.      Sokoloski, Wikstrom), Computing Reviews, May 1992 (CR number
  171.      9205-0262).
  172.  
  173.  
  174. ---------
  175. 1.4) Where is a good place to look for information about current
  176.      research in functional languages?
  177.  
  178. Here are some good places to start:
  179.  
  180. Journals:
  181.   o  The Journal of Functional Programming, published by CUP.
  182.   o  Lisp and Symbolic Computation, published by Kluwer.
  183.  
  184. Conference proceedings:
  185.   o  Lisp and Functional programming (LFP).
  186.   o  Functional Programming Languages and Computer Architecture (FPCA).
  187.   o  Principles of Programming Languages (POPL).
  188.   o  European Symposium on Programming (ESOP).
  189.  
  190.   (Most of these are published by the ACM press, or in the Springer
  191.   Verlag Lecture Notes in Computer Science Series).
  192.  
  193.  
  194. ---------
  195. 1.5) What other newsgroups might be of interest to readers of
  196. comp.lang.functional?
  197.  
  198. There are several newsgroups dealing with related languages and
  199. ideas, including:
  200.  
  201.     comp.lang.ml    for discussion related to ML
  202.     comp.lang.scheme    for discussion about Scheme
  203.     comp.lang.lisp    for discussion about Lisp
  204.     comp.lang.apl    for discussion about APL, J, etc.
  205.  
  206.  
  207. ---------
  208. 1.6) Is comp.lang.functional archived anywhere?
  209.  
  210. No, as far as I know, there is no public archive of comp.lang.functional
  211. (but, of course, many readers keep copies of old articles for their
  212. personal use).  The possibility of establishing a public archive
  213. has been raised a number of times in the past but have not been
  214. pursued due to an apparent lack of interest, and concerns that
  215. archiving might discourage novices from posting articles.
  216.  
  217.  
  218. ---------------------------------------------------------------------------
  219. 2) FREQUENT TOPICS OF DISCUSSION:
  220.  
  221. 2.1) What is a monad?
  222. ---------------------
  223. The concept of a monad comes from category theory; I'll spare you
  224. the full details since you can find these in standard text books
  225. on the subject.  Much of the recent interest in monads in functional
  226. programming is the result of recent papers that show how monads
  227. can be used to describe all kinds of different programming language
  228. features -- for example, I/O, manipulation of state, continuations
  229. and exceptions -- in purely functional languages like Haskell.
  230.  
  231.   o  Philip Wadler, Comprehending Monads (from the ACM conference
  232.      on LISP & Functional Programming, Nice, France, 1990).
  233.  
  234.   o  Philip Wadler, The Essence of Functional Programming (from ACM
  235.      Principles of Programming Languages 1992).
  236.  
  237.   o  Simon Peyton Jones and Philip Wadler, Imperative Functional
  238.      Programming (from ACM Principles of Programming Languages 1993).
  239.  
  240. These papers are essential reading for anyone interested in the
  241. use of monads for functional programming.  Copies of these papers
  242. are currently available by anonymous ftp from ftp.dcs.glasgow.ac.uk
  243. in the subdirectory pub/glasgow-fp/papers.
  244.  
  245.  
  246. 2.2) How can I write a parser in a functional language?
  247. -------------------------------------------------------
  248. A parser is a program that converts a list of input tokens, usually
  249. characters, into a value of the appropriate type.  A simple example
  250. might be a function to find the integer value represented by a
  251. string of digits.  A more complex example might be to translate
  252. programs written in a particular concrete syntax into a suitable
  253. abstract syntax as the first stage in the implementation of a
  254. compiler or interpreter.  There are two common ways to write a
  255. parser in a functional language:
  256.  
  257.   o  Using a parser generator tool.  Some functional language
  258.      implementations support tools that generate a parser automatically
  259.      from a specification of the grammar (in much the same way that
  260.      a C programmer uses yacc).  Different tools are available,
  261.      depending on the language and implementation used.
  262.  
  263.   o  Using combinator parsing.  Parsers are represented by functions
  264.      and combined with a small set of combinators, leading to
  265.      parsers that closely resemble the grammar of the language
  266.      being read.  Parsers written in this way can use backtracking.
  267.      The techniques of combinator parsing have been known for quite
  268.      some time.  Two comparatively recent papers on the subject are:
  269.  
  270.        -  "How to Replace Failure with a List of Successes",
  271.           Philip Wadler, FPCA '85, Springer Verlag LNCS 201, 1985.
  272.  
  273.        -  "Higher-order functions for parsing", Graham Hutton,
  274.       Journal of Functional Programming, 2, 3, July 1992.
  275.  
  276.      The latter paper is also available by anonymous ftp from
  277.      ftp.cs.chalmers.se in the file pub/cs-reports/papers/parsing.dvi
  278.      and includes some references to other related papers.
  279.  
  280.  
  281. 2.3) What does it mean to say that a language is strict/non-strict?
  282. --------------------------------------------------------------------
  283. Here's one (operational) way to explain the difference:
  284.  
  285. In a strict language, the arguments to a function are always
  286. evaluated before it is invoked.  As a result, if the evaluation of
  287. an expression exp does not terminate properly (for example, because
  288. it generates a run-time error or enters an infinite loop), then
  289. neither will an expression of the form  f(exp).  ML and Scheme are
  290. both examples of this.
  291.  
  292. In a non-strict language, the arguments to a function are not
  293. evaluated until their values are actually required.  For example,
  294. evaluating an expression of the form f(exp) may still terminate
  295. properly, even if evaluation of exp would not, if the value of
  296. the parameter is not used in the body of f.  Miranda and Haskell
  297. are examples of this approach.
  298.  
  299. It is possible to support a mixture of these two approaches; some
  300. versions of Hope do this.
  301.  
  302.  
  303. 2.4) What about the performance of functional programs?
  304. -------------------------------------------------------
  305. In some circles, programs written in functional languages, have
  306. obtained a reputation for lack of performance.  Part of this results
  307. from the high-level of abstraction that is common in such programs
  308. and from powerful features like higher-order functions, automatic
  309. storage management, etc.  Of course, the performance of functional
  310. languages keeps improving with new developments in compiler
  311. technology.
  312.  
  313. The paper below compares five current implementations of lazy
  314. functional languages:
  315.  
  316.   ``Benchmarking implementations of lazy functional languages''
  317.   P. H. Hartel and K. G. Langendoen FPCA 93, ACM, pp 341-349
  318.   (By ftp: ftp.fwi.uva.nl, directory pub/functional).
  319.  
  320. Experiments with a heavily optimising compiler for Sisal, a strict
  321. functional language, show that functional programs can be faster
  322. than Fortran:
  323.  
  324.   ``Retire FORTRAN? A debate rekindled''
  325.   D. C. Cann, CACM, 35(8), pp. 81-89, Aug. 1992
  326.  
  327.  
  328. 2.5) What is a purely functional language?
  329. ------------------------------------------
  330. This question has been the subject of some debate in recent messages
  331. posted to comp.lang.functional.  It is widely agreed that languages
  332. like Haskell and Miranda are `purely functional', while SML and
  333. Scheme are not.  However, there are some small differences of
  334. opinion about the precise technical motivation for this distinction.
  335. One definition that has been suggested is as follows:
  336.  
  337.   The term `purely functional language' is often used to describe
  338.   languages which perform all their computations via function
  339.   application.  This is in contrast to languages, like Scheme and
  340.   Standard ML, which are predominantly functional but also allow
  341.   `side effects' (computational effects caused by expression
  342.   evaluation which persist after the evaluation is completed).
  343.  
  344.   Sometimes, the term `purely functional' is also used in a broader
  345.   sense to mean languages which might incorporate computational
  346.   effects, but without altering the notion of `function' (as
  347.   evidenced by the fact that the essential properties of functions
  348.   are preserved.)  Typically, the evaluation of an expression can
  349.   yield a `task' which is then executed separately to cause
  350.   computational effects.  The evaluation and execution phases are
  351.   separated in such a way that the evaluation phase does not
  352.   compromise the standard properties of expressions and functions.
  353.   The input/output mechanisms of Haskell, for example, are of this
  354.   kind.
  355.  
  356.  
  357. 2.6) Other subjects:
  358. --------------------
  359. There probably ought to be something here about programming with
  360. GUIs (Fudgets, eXene, etc.), Input/Output, General Foundations
  361. (basics of lambda calculus, perhaps?), and parallelism.  Anybody
  362. want to write some brief comments addressing one/some of these?
  363. (Some sections are already in preparation.)
  364.  
  365.  
  366. ---------------------------------------------------------------------------
  367. 3) LANGUAGE IMPLEMENTATIONS:
  368.  
  369. ASpecT:        ASpecT is a strict functional language, developed at
  370.         the University of Bremen, originally intended as
  371.         an attempt to provide an implementation for (a
  372.         subset of) Algebraic Specifications of Abstract
  373.         Datatypes.  The system was designed to be as
  374.         user-friendly as possible, including overloading
  375.         facilities and a source-level debugger.  Efficiency
  376.         called for call-by-value evaluation and reference
  377.         counting memory management.
  378.  
  379.         Over the years more and more features were added,
  380.         including subsorting, functionals and restricted
  381.         polymorphism. The ASpecT compiler translates the
  382.         functional source code to C, resulting in fast and
  383.         efficient binaries.
  384.  
  385.         The most important application of ASpecT to date
  386.         is the interactive graph visualization system
  387.         daVinci; currently (Oct '93), version 1.2 is composed
  388.         of 23.000 lines of code. For more information please
  389.         contact the project daVinci by e-mail:
  390.         daVinci@Informatik.Uni-Bremen.DE
  391.  
  392.         ASpecT is available by anonymous FTP from
  393.         wowbagger.PC-Labor.Uni-Bremen.DE in the directory
  394.         /pub/lang/ASpecT. ASpecT has been ported to many
  395.         platforms like Sun3, Sun4, Dec VAX, IBM RS6000,
  396.         NeXT, Apple A/UX, PC (OS/2, Linux), Amiga and Atari
  397.         ST/TT.
  398.  
  399.  
  400. Caml Light:     Caml Light is an implementation of the ML language
  401.         that does not comply to the Standard, but is
  402.         distinguished by its small size, modest memory
  403.         requirements, availability on microcomputers, simple
  404.         separate compilation, interface with C, and portable
  405.         graphics functions.
  406.  
  407.         Caml Light 0.6 runs on most Unix machines, on the
  408.         Macintosh and on PCs under MSDOS.
  409.  
  410.         ftp: ftp.inria.fr, directory lang/caml-light
  411.  
  412.  
  413. Clean:          The Concurrent Clean system is a programming
  414.         environment for the functional language Concurrent
  415.         Clean, developed at the University of Nijmegen,
  416.         The Netherlands. The system is one of the fastest
  417.         implementations of functional languages available
  418.         at the moment. Its I/O libraries make it possible
  419.         to do modern, yet purely functional I/O (including
  420.         windows, menus, dialogs etc.) in Concurrent Clean.
  421.         With the Concurrent Clean system it is possible to
  422.         develop real-life applications in a purely functional
  423.         language.  Particular features include:
  424.  
  425.           o lazy and purely functional
  426.           o strongly typed - based on Milner/Mycroft scheme
  427.           o module structure
  428.           o modern I/O
  429.           o programmer-influenced evaluation order by
  430.                     annotations
  431.  
  432.         ftp: host ftp.cs.kun.nl,  directory pub/Clean
  433.         available for: Mac, Sun 3, Sun 4
  434.  
  435.         There is a book describing Concurrent Clean and
  436.         its implementation on sequential and parallel
  437.         architectures:
  438.  
  439.         "Functional Programming and Parallel Graph Rewriting",
  440.         Rinus Plasmeijer and Marko van Eekelen,
  441.         Addison Wesley, International Computer Science Series.
  442.         Hardcover, 571 pages.
  443.         ISBN 0-201-41663-8
  444.  
  445.  
  446. Erlang:        Concurrent functional programming language for
  447.         large industrial real-time systems. Untyped.
  448.         Pattern matching syntax.  Recursion equations.
  449.         Explicit concurrency, asynchronous message
  450.         passing.  Relatively free from side effects.
  451.         Transparent cross-platform distribution.  Primitives
  452.         for detecting run-time errors.  Real-time GC.
  453.         Modules.  Dynamic code replacement (change code
  454.         in running real-time system, without stopping
  455.         system).  Foreign language interface.
  456.  
  457.         Availability: Free version (subject to non-commercial
  458.         license) with no support.  Commercial versions
  459.         with support are available (Erlang Systems AB).
  460.  
  461.         Info: erlang@erix.ericsson.se
  462.         FTP Info: euagate.eua.ericsson.se:/pub/eua/erlang/info
  463.  
  464.         See also:
  465.         "Concurrent Programming in Erlang", J. Armstrong,
  466.         M. Williams & R. Virding, Prentice Hall, 1993.
  467.         ISBN 13-285792-8.
  468.  
  469.         A DOS/Windows version of Erlang 4.2, requiring a
  470.         386/486 machine  with at least 4 Mbytes of memory
  471.         is now available by anonymous ftp from:
  472.  
  473.         FTP: euagate.eua.ericsson.se:/pub/eua/erlang/release
  474.  
  475.  
  476. FP:             Backus' side-effect free, combinator style language
  477.         described by:
  478.  
  479.         "Can Programming be Liberated from the Von
  480.         Neumann Style?", J. Backus, Communications of the
  481.         ACM, 21, 8, pp.613-641, 1978.
  482.  
  483.         There are (at least) three easily accessible
  484.         implementations of FP.  Two of these are available
  485.         from any site that archives comp.sources.unix.
  486.         For example, at gatekeeper.dec.com you will find
  487.         these in:
  488.  
  489.          pub/usenet/comp.sources.unix/volume13/funcproglang
  490.          pub/usenet/comp.sources.unix/volume20/fpc
  491.  
  492.         The first of these is an interpreter, the second a
  493.         translator from FP to C.
  494.  
  495.         The third implementation, IFP is described separately
  496.         below.
  497.  
  498.  
  499. Gofer:        The Gofer system provides an interpreter for a small
  500.         language based closely on the current version of
  501.         the Haskell report.  In particular, Gofer supports
  502.         lazy evaluation, higher-order functions, polymorphic
  503.         typing, pattern-matching, support for overloading, etc.
  504.  
  505.         ftp: nebula.cs.yale.edu,  directory: pub/haskell/gofer
  506.  
  507.         Gofer runs on a wide range of machines including
  508.         PCs, Ataris, Amigas, etc.  as well as larger
  509.         Unix-based systems.  A version for the Apple
  510.         Macintosh has been produced and is available by
  511.         anonymous ftp from ftp.dcs.glasgow.ac.uk in a
  512.         subdirectory of pub/haskell/gofer.
  513.  
  514.         The implementation of Gofer is described in technical
  515.         report YALEU/DCS/RR-1030, available by anonymous
  516.         ftp from nebula.cs.yale.edu in the directory
  517.         pub/yale-fp/reports.
  518.  
  519.         Please note the spelling, derived from the notion
  520.         that functional languages are GOod For Equational
  521.         Reasoning.  This is not to be confused with `Gopher',
  522.         the widely used Internet distributed information
  523.         delivery system!
  524.  
  525.  
  526. Haskell:    In the mid-1980s, there was no "standard" non-strict,
  527.         purely-functional programming language.  A
  528.         language-design committee was set up in 1987, and
  529.         the Haskell language is the result.
  530.  
  531.         The Haskell committee released its report on 1
  532.         April 1990. A revised "Version 1.2" appeared in
  533.         SIGPLAN Notices 27(5) (May 1992), along with a
  534.         tutorial on Haskell by Hudak and Fasel.
  535.  
  536.         At the time of writing, there are three different
  537.         Haskell systems available, developed by groups at
  538.         Chalmers, Glasgow and Yale (several others are
  539.         being developed).  These systems are available
  540.         from the following sites:
  541.            Chalmers    ftp.cs.chalmers.se
  542.            Glasgow    ftp.dcs.glasgow.ac.uk
  543.            Yale        nebula.cs.yale.edu
  544.         At each site, all of the files related to Haskell
  545.         are stored in the directory pub/haskell.  Specialized
  546.         material, or recent releases of these systems may
  547.         sometimes only be available from the systems ``home
  548.         site''.  Machine-readable versions of the Haskell
  549.         report, tutorials, and some programs are also
  550.         available at these sites.
  551.  
  552.         A description of the current status of the various
  553.         Haskell implementations is occasionally posted on
  554.         the Haskell mailing list, and sometimes on
  555.         comp.lang.functional.  Copies of this document are
  556.         often kept on the Haskell sites mentioned above.
  557.         For example, this information may be found in
  558.         pub/haskell/papers/Haskell.status at the Yale site
  559.         (nebula.cs.yale.edu).
  560.  
  561.  
  562. Hope:        A small polymorphically-typed functional language.
  563.         First language to use call-by-pattern.    Hope was
  564.         originally strict, but there are versions with lazy
  565.         lists, or with lazy constructors but strict functions.
  566.         A fully lazy interpreter is available from:
  567.  
  568.         ftp: santos.doc.ic.ac.uk:/pub/papers/R.Paterson/hope.tar.Z
  569.  
  570.  
  571. Id:             The core of Id is a non-strict functional language
  572.         with implicit parallelism.  It has the usual features
  573.         of many modern functional languages, including a
  574.         Hindley/Milner type inference system, algebraic
  575.         types and definitions with clauses and pattern
  576.         matching, and list comprehensions.
  577.  
  578.  
  579. IFP:            The Illinois FP system is a modified version of
  580.         Backus' FP with a more Algol-like syntax and
  581.         structure.  Described in:
  582.  
  583.         "The Illinois Functional Programming Interpreter",
  584.         Arch D. Robison, Proceedings of the SIGPLAN '87
  585.         Symposium on Interpreters and Interpretive Techniques,
  586.         SIGPLAN notices vol 22, no 7, July 1987.
  587.  
  588.         ftp: a.cs.uiuc.edu.    versions for Unix and MSDOS
  589.  
  590.  
  591. J:              J was designed and developed by Ken Iverson and
  592.         Roger Hui.  It is similar to the language APL,
  593.         departing from APL in using using the ASCII alphabet
  594.         exclusively, but employing a spelling scheme that
  595.         retains the advantages of the special alphabet
  596.         required by APL. It has added features and control
  597.         structures that extend its power beyond standard
  598.         APL.  Although it can be used as a conventional
  599.         procedural programming language, it can also be
  600.         used as a pure functional programming language.
  601.  
  602.         ftp: watserv1.waterloo.edu.
  603.  
  604.  
  605. Miranda(TM):    Miranda was designed in 1985-6 by David Turner with
  606.         the aim of providing a standard non-strict purely
  607.         functional language.  It is described in D. A.
  608.         Turner ``Miranda: A Non-Strict Functional Language
  609.         with Polymorphic Types'', Proceedings FPLCA, Nancy,
  610.         France, September 1985 (Springer LNCS vol 201, pp
  611.         1-16) and D. A. Turner ``An Overview of  Miranda'',
  612.         SIGPLAN Notices, vol 21, no 12, pp 158-166 (December
  613.         1986).
  614.  
  615.         Miranda was the first widely disseminated language
  616.         with non-strict semantics and polymorphic strong
  617.         typing, and is now running at over 600 sites,
  618.         including 250 universities.  It is widely used for
  619.         teaching, often in conjunction with "Introduction
  620.         to Functional Programming", by Bird & Wadler, which
  621.         uses a notation closely based on Miranda.
  622.  
  623.         It has also had a strong influence on the subsequent
  624.         development of the field and provided one of the
  625.         main inputs for the design of the later language
  626.         Haskell (see separate entry).
  627.  
  628.         Miranda was awarded a medal for technical achievement
  629.         by the British Computer Society (BCS Awards, 1990).
  630.  
  631.         The Miranda system is a commercial product of
  632.         Research Software Limited.  Miranda release two
  633.         (the current version) supports unbounded precision
  634.         integers and has a module system with provision
  635.         for parameterized modules and a built in "make"
  636.         facility.  The compiler works in conjunction with
  637.         a screen editor and programs are automatically
  638.         recompiled after edits.  There is an online reference
  639.         manual.
  640.  
  641.         Note that the word "Miranda" is a trademark (TM)
  642.         of Research Software Limited.  There are no public
  643.         domain versions of Miranda.
  644.  
  645.         Further information about Miranda may be obtained
  646.         from
  647.                    mira-request@ukc.ac.uk
  648.                 or
  649.                    Research Software Ltd
  650.                    23 St Augustines Road
  651.                    Canterbury CT1 1XP       phone: (+44) 227 471844
  652.                    ENGLAND                  fax:   (+44) 227 454458
  653.  
  654.  
  655. ML:             ML (which stands for Meta-Language) is a family of
  656.         advanced programming languages with [usually]
  657.         functional control structures, strict semantics,
  658.         a strict polymorphic type system, and parameterized
  659.         modules.  It includes Standard ML, Lazy ML, CAML,
  660.         CAML Light, and various research languages.
  661.         Implementations are available on many platforms,
  662.         including PCs, mainframes, most models of workstation,
  663.         multi-processors and supercomputers.  ML has many
  664.         thousands of users, is taught at many universities
  665.         (and is the first programming language taught at
  666.         some).
  667.  
  668.         There is a moderated usenet newsgroup, comp.lang.ml,
  669.         for the discussion of topics related to ML.  A list
  670.         of frequently asked questions for ML is posted to
  671.         this group each month by the moderator, Greg
  672.         Morrisett.  The first paragraph above is taken
  673.         directly from this FAQ.
  674.  
  675.         There are several implementations of ML including
  676.         Poly/ML, SML/NJ, PoplogML, Edinburgh, ANU ML, Micro
  677.         ML, sml2c, Caml Light, and the ML kit.  Further
  678.         details for each of these systems are included in
  679.         the comp.lang.ml FAQ.
  680.  
  681.         The Standard ML language is formally defined by:
  682.  
  683.         "The Definition of Standard ML", Robin Milner, Mads
  684.         Tofte and Robert Harper, MIT, 1990.  ISBN:
  685.         0-262-63132-6
  686.  
  687.         "Commentary on Standard ML", Robin Milner and Mads
  688.         Tofte, MIT, 1991 ISBN: 0-262-63137-7
  689.  
  690.         There are a number of texts describing programming
  691.         in ML.  Again, full details are given in the
  692.         comp.lang.ml FAQ.
  693.  
  694.  
  695. NESL:        NESL is a fine-grained, functional, nested
  696.         data-parallel language.  The current implementation
  697.         runs on workstations, the Connection Machines CM2
  698.         and CM5, the Cray Y-MP and the MasPar MP2.
  699.  
  700.         NESL is loosely based on ML.  It includes a built-in
  701.         parallel data-type, sequences, and parallel operations
  702.         on sequences (the element type of a sequence can
  703.         be any type, not just scalars).  It is based on
  704.         eager evaluation, and supports polymorphism, type
  705.         inference and a limited use of higher-order functions.
  706.         Currently it does not have support for modules and
  707.         its datatype definition is limited.  Except for
  708.         I/O and some system utilities it is purely functional
  709.         (it does not support reference cells or call/cc).
  710.         The compiler is based on delayed compilation and
  711.         compiles separate code for each type a function is
  712.         used with (compiled code is monomorphic).  The
  713.         implementation therefore requires no type bits,
  714.         and can do some important data-layout optimizations
  715.         (e.g. double-precision floats don't need to be
  716.         boxed, and nested sequences can be laid out
  717.         efficiently across multiple processors).  For
  718.         several small benchmark applications on irregular
  719.         and/or dynamic data (e.g graphs and sparse matrices)
  720.         it generates code comparable in efficiency to
  721.         machine-specific low-level code (e.g. Fortran or C).
  722.  
  723.         The system is available via anonymous FTP to
  724.         nesl.scandal.cs.cmu.edu (currently 128.2.222.128),
  725.         in the file code/nesl/nesl.tar.Z (1.2Mbytes).
  726.         There is a README file in the nesl directory that
  727.         contains further information.  You can be added to
  728.         the NESL mailing list by sending e-mail to
  729.         nesl-request@cs.cmu.edu.  The examples and
  730.         documentation are also available separately.
  731.  
  732.  
  733. OPAL:        The language OPAL has been designed as a testbed
  734.         for the development of functional programs. Opal
  735.         molds concepts from Algebraic Specification and
  736.         Functional Programming, which shall favor the
  737.         (formal) development of (large) production-quality
  738.         software that is written in a purely functional
  739.         style.
  740.  
  741.         The core of OPAL is a strongly typed, higher-order,
  742.         strict applicative language which belongs to the
  743.         tradition of HOPE and ML. The algebraic flavour of
  744.         OPAL shows up in the syntactical appearance and
  745.         the preference of parameterization to polymorphism.
  746.  
  747.         OPAL is used for research on the highly optimizing
  748.         compilation of applicative languages. This has
  749.         resulted in a compiler which produces very efficient
  750.         code. The OPAL compiler itself is entirely written
  751.         in OPAL.
  752.  
  753.         Papers describing OPAL, and the OPAL compilation
  754.         system itself, are available by anonymous ftp from:
  755.  
  756.             ftp.cs.tu-berlin.de
  757.  
  758.         This includes an overview of OPAL in the file:
  759.  
  760.             pub/local/uebb/papers/DesignImplOpal.ps.gz
  761.  
  762.         A language tutorial:
  763.  
  764.             pub/local/uebb/papers/TutorialOpal.ps.gz
  765.  
  766.         The compilation system is in the pub/local/uebb/ocs
  767.         directory.  Installation is straightforward and
  768.         has been successfully performed for SPARCs,
  769.         DECstations, NeXTs, and PCs running LINUX.
  770.  
  771.                 The OPAL distribution is also available from:
  772.  
  773.                     ftp.fu-berlin.de   in  pub/unix/languages/opal
  774.  
  775.                 and, in the US, from:
  776.  
  777.                     ftp.isi.edu    in opal/
  778.  
  779.  
  780. Scheme:        Scheme is a dialect of Lisp that stresses conceptual
  781.         elegance and simplicity. It is specified in R4RS
  782.         and IEEE standard P1178. (See question [1-7] for
  783.         details on standards for Scheme.) Scheme is much
  784.         smaller than Common Lisp; the specification is
  785.         about 50 pages.
  786.  
  787.         Scheme is often used in computer science curricula
  788.         and programming language research, due to its
  789.         ability to represent many programming abstractions
  790.         with its simple primitives.
  791.  
  792.         There is an unmoderated usenet newsgroup,
  793.         comp.lang.scheme for the discussion of topics
  794.         related to Scheme, and a list of frequently asked
  795.         questions for Scheme is posted to the group each
  796.         month by Mark Kantrowitz.  The FAQ list is also
  797.         available online from several sources; for example,
  798.         it can be obtained by anonymous ftp from ftp.think.com
  799.         in the file /public/think/lisp/scheme-faq.text.
  800.  
  801.         There are many books and papers dealing with Scheme.
  802.         Please consult the comp.lang.scheme frequently
  803.         asked questions list for further details.
  804.  
  805.         The Scheme Repository, maintained by Ozan S. Yigit,
  806.         is accessible by anonymous ftp at nexus.yorku.ca
  807.         [130.63.9.66] in the directory pub/scheme/, and
  808.         contains a Scheme bibliography, copies of the R4RS
  809.         report, IEEE P1178 specification and other papers,
  810.         sample Scheme code for a variety of purposes,
  811.         several utilities, and some implementations.  The
  812.         repository is mirrored in INRIA, courtesy of
  813.         Christian Queinnec [Ecole Polytechnique and
  814.         INRIA-Rocquencourt], ftp.inria.fr:lang/Scheme.
  815.  
  816.  
  817. Sisal:          Sisal (Streams and Iteration in a Single Assignment
  818.         Language) is a functional language designed with
  819.         several goals in mind:  to support clear, efficient
  820.         expression of scientific programs; to free application
  821.         programmers from details irrelevant to their
  822.         endeavors; and, to allow automatic detection and
  823.         exploitation of the parallelism expressed in source
  824.         programs.
  825.  
  826.         Sisal syntax is modern and easy to read; Sisal code
  827.         looks similar to Pascal, Modula, or Ada, with modern
  828.         constructs and long identifiers. The major difference
  829.         between Sisal and more conventional languages is
  830.         that it does not express explicit program control flow.
  831.  
  832.         Sisal semantics are mathematically sound. Programs
  833.         consist of function definitions and invocations.
  834.         Functions have no side effects, taking as inputs
  835.         only explicitly passed arguments, and producing
  836.         only explicitly returned results. There is no
  837.         concept of state in Sisal.  Identifiers are used,
  838.         rather than variables, to denote values, rather
  839.         than memory locations.
  840.  
  841.         The Sisal language currently exists for several
  842.         shared memory and vector systems that run Berkeley
  843.         Unix(tm), including the Sequent Balance and Symmetry,
  844.         the Alliant, the Cray X/MP and Y/MP, Cray 2, and
  845.         a few other less well-known ones.  Sisal is available
  846.         on sequential machines such as Sparc, RS/6000, and
  847.         HP.  Sisal also runs under MS-DOS and Macintosh
  848.         Unix (A/UX). It's been shown to be fairly easy to
  849.         port the entire language system to new machines.
  850.  
  851.         ftp: sisal.llnl.gov (128.115.19.65)
  852.  
  853.         For more information, pleases send an email request to:
  854.             sisal-info-request@sisal.llnl.gov
  855.  
  856.         See also: "Retire FORTRAN? A debate rekindled",
  857.         David Cann, CACM, 35(8), pp.81-89, Aug 1992
  858.  
  859.  
  860. ---------------------------------------------------------------------------
  861. 4) OTHER RESOURCES:
  862.  
  863. 4.1) Bibliographies:
  864.  
  865.   o  Mike Joy maintains a bibliography on Functional Languages,
  866.      in refer(1) format.  It is available by anonymous ftp from:
  867.      ftp.dcs.warwick.ac.uk in the files:
  868.  
  869.        pub/biblio/functional.README pub/biblio/functional.refer.Z
  870.  
  871.   o  Tony Davie maintains a bibliography of over 2,600 papers,
  872.      articles and books on functional programming and functional
  873.      systems.  It can be obtained by anonymous ftp from
  874.      tamdhu.dcs.st-and.ac.uk in the directory pub/staple, either
  875.      as a hypercard stack in pubs.sit.Hqx, or as a (compressed)
  876.      text file in pubs.txt.Z.
  877.  
  878.   o  Wolfgang Schreiner has compiled an annotated bibliography
  879.      on parallel functional programming that lists more than 350
  880.      publications mostly including their *full abstracts*.
  881.  
  882.      You can retrieve the bibliography by anonymous ftp from
  883.      ftp.risc.uni-linz.ac.at (193.170.36.100) in
  884.      pub/reports/parlab/pfpbib2.dvi.Z (or pfpbib2.ps.Z).
  885.  
  886.   o  State in Functional Programming: An Annotated Bibliography,
  887.      edited by P. Hudak and D. Rabin, is available by anonymous
  888.      ftp from nebula.cs.yale.edu in the files:
  889.  
  890.        pub/yale-fp/papers/state-bib.<format>.<compression> where
  891.        <format>      ::= ps | dvi
  892.          <compression> :: = z | Z
  893.  
  894.  
  895. 4.2) Translators:
  896.  
  897.   o  Miranda(TM) to LML and Miranda(TM) to Haskell translators
  898.      written by Denis Howe are available by anonymous ftp from
  899.      wombat.doc.ic.ac.uk (146.169.22.42) in directory pub, files
  900.      mira2hs-1.05 and mira2lml-0.00
  901.  
  902.  
  903. 4.3) Online services:
  904.  
  905.   o If you have wais, the source is listed below, or it can be
  906.     easily obtained from the directory-of-servers. If you don't
  907.     have wais, subscribe to comp.infosystems.wais and find someone
  908.     to ask.
  909.  
  910.     (:source
  911.        :version  3 :ip-address "137.219.17.4" :ip-name
  912.        "coral.cs.jcu.edu.au" :tcp-port 8000 :database-name
  913.        "Func-Prog-Abstracts" :cost 0.00 :cost-unit :free :maintainer
  914.        "farrell@coral.cs.jcu.edu.au" :description "Server created
  915.        with WAIS release 8 b3.1
  916.      on Apr 22 19:06:25 1992 by farrell@coral.cs.jcu.edu.au
  917.  
  918.      Keywords: help intro introduction info information computer
  919.     science technical reports functional programming
  920.  
  921.      This is a small collection of computer science technical
  922.      reports, abstracts and papers gathered from ftp sites etc.
  923.      all over the world. Due to space considerations, I am limiting
  924.      it to functional programming, my area of interest, and papers
  925.      produced by the department (which may or may not be related
  926.      to functional programming).
  927.  
  928.      Comments, problems etc to the maintainer above.  " )
  929.  
  930.  
  931.   o The Free On-Line Dictionary of Computing is available by Gopher
  932.     and FTP from wombat.doc.ic.ac.uk.  It is not restricted to
  933.     functional programming but does include quite a few FP terms.
  934.  
  935.  
  936.   o There are a number of pages on the World-Wide-Web that may be
  937.     useful to those with an interest in functional programming.
  938.     These include:
  939.  
  940.     John Farrell's functional programming page:
  941.  
  942.        ftp://coral.cs.jcu.edu.au/web/FP/home.html
  943.  
  944.     The Glasgow functional programming page:
  945.  
  946.        ftp://ftp.dcs.glasgow.ac.uk/pub/glasgow-fp/glasgow-fp.html
  947.  
  948.     Mark Leone's programming language research page:
  949.  
  950.        http://www.cs.cmu.edu:8001
  951.               /afs/cs.cmu.edu/user/mleone/web/language-research.html
  952.  
  953.     (For more information on the World-Wide Web, see the WWW FAQ,
  954.     available by anonymous FTP from rtfm.mit.edu as
  955.     /pub/usenet/news.answers/www/faq.)
  956.  
  957.  
  958. ---------------------------------------------------------------------------
  959. 5) CREDITS AND DISCLAIMERS:
  960.  
  961. The information in this article has been taken from public sources,
  962. mostly from articles posted on comp.lang.functional during the past
  963. eighteen months.  This FAQ includes contributions from many different
  964. people -- because of the way that the FAQ was compiled, I regret
  965. to say that I do not have a complete list of contributors.
  966.  
  967. The aim of this FAQ is to provide information about functional
  968. languages and to reflect widely held views in the functional
  969. programming community.  Any opinions expressed in this message are
  970. those of the individual contributors, and may not be representative
  971. either of my own personal views, or of others in the community.
  972.  
  973. It is very likely that this FAQ contains some significant errors
  974. and omissions: There are no guarantees for the accuracy of the
  975. information provided here.  Of course, your corrections and
  976. contributions are encouraged!
  977.  
  978.  
  979. ---------------------------------------------------------------------------
  980.  
  981.